सी में नेस्टेड लूप

नेस्टेड लूप का वाक्य

AaUTrRlaupa
{
AaMtarikRpafMDe
{
// AaMtarik kuMdlai kYana.
}
// AaUTr kuMdlai kYana.
}

OUTER_LOOP और INNER_LOOP वैध लूप हैं जो 'लूप' के लिए 'लूप या' डो-व्हाइल 'लूप के लिए' हो सकते हैं।

लूप के लिए नेस्टेड

लूप के लिए नेस्टेड का मतलब किसी भी प्रकार का लूप है जो 'लूप के लिए' के ​​अंदर परिभाषित होता है।

jaba (pzaarMBa; sYaitai; ALa tana)
{
jaba(pzaarMBa; sYaitai; ALa tana)
{
// AaMtarik kuMdlai kYana.
}
// AaUTr kuMdlai kYana.
}

लूप के लिए नेस्टेड का उदाहरण

#EZstamaalakre <PsaTidiAayaAae.Pca>
paunaZ mauqya()
{
paunaZ Pna;// car oaaeSanaa
laiqaiyae("pzavaeSa krnaa kimata ka n :");
// pzaDSZaita Pna Tebala.
jaba(paunaZ maIM=1;maIM<=Pna;maIM++) // AaUTr kuMdlai
{
jaba(paunaZ jae=1;jae<=10;jae++) // AaMtarik kuMdlai
{
laiqaiyae("%paunaZ\t",(maIM*jae)); // CpaaEZ kimata.
}
laiqaiyae("\n");
}

उपरोक्त कोड की व्याख्या

सबसे पहले, 'I' वैरिएबल को 1 से आरंभ किया जाता है और फिर प्रोग्राम कंट्रोल I <= n तक जाता है। कार्यक्रम नियंत्रण जांचता है कि क्या स्थिति 'i <= n' सच है या नहीं। यदि स्थिति सच है, तो कार्यक्रम नियंत्रण आंतरिक लूप में गुजरता है। आंतरिक लूप तब तक निष्पादित हो जाएगा जब तक कि स्थिति सही नहीं है। आंतरिक लूप के निष्पादन के बाद, नियंत्रण बाहरी लूप के अद्यतन पर वापस चला जाता है, यानी, i ++। लूप काउंटर के मान को बढ़ाने के बाद, स्थिति को फिर से जांचा जाता है, अर्थात, मैं <= n। यदि स्थिति सच है, तो आंतरिक लूप को फिर से निष्पादित किया जाएगा। यह प्रक्रिया तब तक जारी रहेगी जब तक कि बाहरी लूप की स्थिति सच नहीं होती।

लूप के दौरान नेस्टेड

लूप के दौरान नेस्टेड का मतलब किसी भी प्रकार का लूप है जो 'जबकि' लूप के अंदर परिभाषित होता है।

jabatak(sYaitai)
{
jabatak(sYaitai)
{
// AaMtarik kuMdlai kYana.
}
// AaUTr kuMdlai kYana.
}

लूप के दौरान नेस्टेड का उदाहरण

#EZstamaalakre <PsaTidiAayaAae.Pca>
paunaZ mauqya()
{
paunaZ paMKtaiyaaeM; // car oaaeSanaa
paunaZ klama; // car oaaeSanaa
paunaZ a=1; // car pzaarMBa
laiqaiyae("pzavaeSa krnaa saMqyaa ka paMKtaiyaaeM :"); // EnapauT saMqyaa ka paMKtaiyaaeM.
laijaiyae("%paunaZ",&paMKtaiyaaeM);
laiqaiyae("\naeMTr saMqyaa ka klama :"); // EnapauT saMqyaa ka klama.
laijaiyae("%paunaZ",&klama);
paunaZ P[paMKtaiyaaeM][klama]; //2Rdi sarnai oaaeSanaa
paunaZ maIM=1;
jabatak(maIM<=paMKtaiyaaeM) // AaUTr kuMdlai
{
paunaZ jae=1;
jabatak(jae<=klama) // AaMtarik kuMdlai
{
laiqaiyae("%paunaZ\t",a); // CpaaEZ kimata ka a.
a++; // vaetanaRvaoDi vairaeoaRkrnaa
jae++;
}
maIM++;
laiqaiyae("\n");
}
}

उपरोक्त कोड की व्याख्या।

हमने 2 डी सरणी बनाई है, अर्थात, इंट ए [पंक्तियाँ] [कॉलम]। कार्यक्रम 1 से 'I' चर को इनिशियलाइज़ करता है। अब, नियंत्रण जबकि लूप में चलता है, और यह लूप जांचता है कि क्या स्थिति सच है, तो कार्यक्रम नियंत्रण आंतरिक लूप में चला जाता है। आंतरिक लूप के निष्पादन के बाद, नियंत्रण बाहरी लूप के अद्यतन में चला जाता है, यानी, i ++। 'I' के मान को बढ़ाने के बाद, स्थिति (i <= पंक्तियाँ) की जाँच की जाती है। यदि स्थिति सच है, तो नियंत्रण फिर से आंतरिक लूप में चला जाता है। यह प्रक्रिया तब तक जारी रहती है जब तक कि बाहरी लूप की स्थिति सच नहीं होती।

नेस्टेड डू। लूप

नेस्टेड डू।

kre
{
kre
{
// AaMtarik kuMdlai kYana.
}jabatak(sYaitai);
// AaUTr kuMdlai kYana.
}jabatak(sYaitai);

नेस्टेड डू का उदाहरण। लूप।

#EZstamaalakre <PsaTidiAayaAae.Pca>
paunaZ mauqya()
{
/*CpaaEZ namaunaa
********
********
********
******** */
paunaZ maIM=1;
kre // AaUTr kuMdlai
{
paunaZ jae=1;
kre // AaMtarik kuMdlai
{
laiqaiyae("*");
jae++;
}jabatak(jae<=8);
laiqaiyae("\n");
maIM++;
}jabatak(maIM<=4);
}

उपरोक्त कोड की व्याख्या।

सबसे पहले, हम बाहरी लूप काउंटर वैरिएबल को इनिशियलाइज़ करते हैं, अर्थात्, 'I' 1 से। जैसा कि हम जानते हैं कि DO..While लूप स्थिति की जाँच किए बिना एक बार निष्पादित करता है, इसलिए बाहरी लूप को बाहरी लूप में स्थिति की जाँच किए बिना आंतरिक लूप निष्पादित किया जाता है। आंतरिक लूप के निष्पादन के बाद, नियंत्रण I ++ के अद्यतन के लिए चलता है। जब लूप काउंटर मूल्य बढ़ाया जाता है, तो स्थिति की जाँच की जाती है। यदि बाहरी लूप में स्थिति सच है, तो आंतरिक लूप को निष्पादित किया जाता है। यह प्रक्रिया तब तक जारी रहेगी जब तक कि बाहरी लूप में स्थिति सच नहीं होती।